home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1998 / MacHack 1998.toast / The Hacks! / COSEmulator / COSEmulator- SRC / headers / LinkedList.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-21  |  6.2 KB  |  263 lines  |  [TEXT/CWIE]
  1. #ifndef    _LinkedList_h_
  2. #define _LinkedList_h_
  3.  
  4.  
  5. template< class T >
  6. class    LinkListClass
  7. {
  8. public:
  9.  
  10. T        *FirstInList( void );        // returns the what is first in the list
  11. T        *LastInList( void );
  12.  
  13. protected:
  14.  
  15.     LinkListClass( void );
  16.     ~LinkListClass( void );
  17.     
  18. void    RemoveFromList( T * );
  19. void    TempRemoveFromList( T * );
  20. void    MoveAfter( T * , T * );
  21. void    MoveBefore( T *, T * );
  22. void    AddToList(    T * );            // all ready declare with new before passing;
  23. void    DeleteAllList( void );
  24.  
  25. T        *FirstLink;
  26. T        *LastLink;
  27. short    howMany;
  28.  
  29.  
  30.  
  31. };
  32.  
  33. //------------------------------------------------------------------------------\\
  34. //        LinkListClass ::     LinkListClass                                        ||
  35. //                                                                                ||
  36. //            Constructor -     sets everything up                                    ||
  37. //                                                                                ||
  38. //------------------------------------------------------------------------------//
  39.  
  40. template < class T >
  41.     LinkListClass< T > :: LinkListClass( void )
  42. {
  43.  
  44. howMany = 0;
  45. FirstLink = nil;
  46. LastLink = nil;
  47. }
  48.  
  49. //------------------------------------------------------------------------------\\
  50. //        LinkListClass ::     ~LinkListClass                                        ||
  51. //                                                                                ||
  52. //            Destructor - deletes all data in the list                            ||
  53. //                                                                                ||
  54. //------------------------------------------------------------------------------//
  55.  
  56. template< class T >
  57.     LinkListClass< T > :: ~LinkListClass( void )
  58. {
  59.     DeleteAllList();
  60. }
  61. //------------------------------------------------------------------------------\\
  62. //        LinkListClass ::     RemoveFromList                                        ||
  63. //                                                                                ||
  64. //            Removes a link from the list                                        ||
  65. //                                                                                ||
  66. //------------------------------------------------------------------------------//
  67.  
  68. template< class T >
  69. void    LinkListClass< T > :: RemoveFromList( T *deleteMe )
  70. {
  71.  
  72. if( deleteMe != nil )
  73.     {
  74.     // This is here so that it is saved
  75.     if( LastLink == deleteMe )
  76.         LastLink = deleteMe->previous; 
  77.     
  78.     if( deleteMe->previous != nil )
  79.         deleteMe->previous->next = deleteMe->next;
  80.  
  81.     if( deleteMe->next != nil )
  82.         deleteMe->next->previous = deleteMe->previous;
  83.  
  84.     
  85.     if( deleteMe == FirstLink )
  86.         FirstLink = deleteMe->next; 
  87.         
  88.     delete deleteMe;
  89.     
  90.     howMany--;
  91.     }
  92. }
  93.  
  94. //------------------------------------------------------------------------------\\
  95. //        LinkListClass ::     TempRemoveFromList                                    ||
  96. //                                                                                ||
  97. //            Removes a link from the list - but doesnt delete it                    ||
  98. //                                                                                ||
  99. //------------------------------------------------------------------------------//
  100.  
  101. template< class T >
  102. void    LinkListClass< T > :: TempRemoveFromList( T *removeMe )
  103. {
  104.  
  105. if( removeMe != nil )
  106.     {
  107.     // This is here so that it is saved
  108.     if( LastLink == removeMe )
  109.         LastLink = removeMe->previous; 
  110.     
  111.     if( FirstLink == removeMe )
  112.         FirstLink = removeMe->next;
  113.     
  114.     if( removeMe->previous != nil )
  115.         removeMe->previous->next = removeMe->next;
  116.  
  117.     if( removeMe->next != nil )
  118.         removeMe->next->previous = removeMe->previous;
  119.         
  120.     howMany--;
  121.     }
  122. }
  123.  
  124. //------------------------------------------------------------------------------\\
  125. //        LinkListClass ::     MoveAfter                                            ||
  126. //                                                                                ||
  127. //            puts b after a                                                        ||
  128. //                                                                                ||
  129. //------------------------------------------------------------------------------//
  130.  
  131. template< class T >
  132. void    LinkListClass< T > :: MoveAfter( T *a , T *b )
  133. {
  134.     if( a == b )
  135.         return;
  136.             
  137.     if( a == LastLink )
  138.         LastLink = b;
  139.     else if( b = LastLink )
  140.         LastLink = b->previous;
  141.             
  142.     if( b == FirstLink )
  143.         FirstLink = b->next;
  144.                 
  145.     if( b->next != NULL )
  146.         b->next->previous = b->previous;
  147.     
  148.     if( b->previous != NULL )
  149.         b->previous->next = b->next;
  150.     
  151.     if( a->next != NULL )
  152.         a->next->previous = b;
  153.     
  154.     b->next = a->next;
  155.     b->previous = a;
  156.     a->next = b;
  157. }
  158.  
  159. //------------------------------------------------------------------------------\\
  160. //        LinkListClass ::     MoveBefore                                            ||
  161. //                                                                                ||
  162. //            puts b before a                                                        ||
  163. //                                                                                ||
  164. //------------------------------------------------------------------------------//
  165.  
  166. template< class T >
  167. void    LinkListClass< T > :: MoveBefore( T *a , T *b )
  168. {
  169.     if( a == b )
  170.         return;
  171.             
  172.     if( a == FirstLink )
  173.         FirstLink = b;
  174.     else if( b == FirstLink )
  175.         FirstLink = b->next;
  176.         
  177.     if( b == LastLink )
  178.         LastLink = b->previous;
  179.     
  180.     if( b->next != NULL )
  181.         b->next->previous = b->previous;
  182.     
  183.     if( b->previous != NULL )
  184.         b->previous->next = b->next;
  185.     
  186.     if( a->previous != NULL )
  187.         a->previous->next = b;
  188.     
  189.     b->next = a;
  190.     b->previous = a->previous;
  191.     a->previous = b;
  192. }
  193.  
  194. //------------------------------------------------------------------------------\\
  195. //        LinkListClass ::     AddToList                                            ||
  196. //                                                                                ||
  197. //        Adds to the list - make sure the data is already declared before        ||
  198. //        calling                                                                    ||
  199. //------------------------------------------------------------------------------//
  200.  
  201. template < class T >
  202. void    LinkListClass< T > :: AddToList(    T *newLink )
  203. {
  204.  
  205. if( FirstLink != nil )
  206.     FirstLink->previous = newLink;
  207. else
  208.     LastLink = newLink;    // This is here to save the first for later use
  209.     
  210. newLink->next      = FirstLink;
  211. newLink->previous = nil;
  212.  
  213. FirstLink = newLink;
  214.  
  215.  
  216. howMany++;
  217. }
  218.  
  219. //------------------------------------------------------------------------------\\
  220. //        LinkListClass ::     FirstInList                                            ||
  221. //            Returns the address of the last frsit in the list -                 ||
  222. //                                                                                ||
  223. //------------------------------------------------------------------------------//
  224.  
  225. template < class T >
  226. T     *LinkListClass< T > :: FirstInList( void )
  227. {
  228.     return( FirstLink );
  229. }
  230.  
  231. //------------------------------------------------------------------------------\\
  232. //        LinkListClass ::     LastInList                                            ||
  233. //            Returns the address of the last link in the list - Needed? -        ||
  234. //                                                                                ||
  235. //------------------------------------------------------------------------------//
  236.  
  237. template < class T >
  238. T     *LinkListClass< T > :: LastInList( void )
  239. {
  240.     return( LastLink );
  241. }
  242.  
  243. //------------------------------------------------------------------------------\\
  244. //        LinkListClass ::     DeleteAllList                                        ||
  245. //            Deletes everything in the list                                -        ||
  246. //                                                                                ||
  247. //------------------------------------------------------------------------------//
  248.  
  249. template <class T >
  250.  
  251. void    LinkListClass< T > :: DeleteAllList( void )
  252. {
  253. T *tempLink;
  254.  
  255. while( FirstLink != nil )
  256.     {
  257.     tempLink = FirstLink->next;
  258.     delete FirstLink;
  259.     FirstLink = tempLink;
  260.     }
  261. }
  262.  
  263. #endif